home *** CD-ROM | disk | FTP | other *** search
/ Belgian Amiga Club - ADF Collection / BS1 part 19.zip / BS1 part 19 / PD.adf / Surf / REVOLVE.C < prev    next >
C/C++ Source or Header  |  1988-12-14  |  4KB  |  224 lines
  1. #include <math.h>
  2. #include "fasttrig.h"
  3. #include "bezpt.h"
  4. #include "revolve.h"
  5. #include "mytypes.h"
  6.  
  7.  
  8. RevAxisType RevAxis;
  9.  
  10.  
  11. short RevMesh = DefRevMeshVal;
  12. short RevImageR, /* revolution index */
  13.       RevImageB; /* bezier index */
  14.  
  15. static int RotRange = DefRotRange;
  16. static int RotStart = DefRotStart;
  17. static int SecAngle = DefTilt;
  18. static float SurfDist = DefSurfDist;
  19. static float ViewDist = DefViewDist;
  20. static bool Perspective = DefPersp;
  21.  
  22. void SetPerspective(  value)
  23.     int value;
  24. {
  25.     Perspective = value;
  26. }
  27.  
  28.  
  29.  
  30. void SetRevAxis( value)
  31.     int value;
  32. {
  33.     RevAxis = (value)? RevY : RevX;
  34. }
  35.  
  36.  
  37. void SetRotStart( value )
  38.     int value;
  39. {
  40.     RotStart = value;
  41. }
  42.  
  43. void SetRotRange(  value )
  44.     int value;
  45. {
  46.     RotRange = value;
  47. }
  48.  
  49. void SetSecAng( value )
  50.     int value;
  51. {
  52.     SecAngle = value;
  53. }
  54.  
  55. void SetRevMesh( value )
  56.     int value;
  57. {
  58.     RevMesh = value;
  59. }
  60.  
  61.  
  62. void SetSurfDist( value )
  63.     int value;
  64. {
  65.     SurfDist = (float )value;
  66. }
  67.  
  68.  
  69. void SetViewDist( value )
  70.     int value;
  71. {
  72.     ViewDist = (float )value;
  73. }
  74.  
  75.  
  76.  
  77. static
  78. float secsin, seccos; /* trig values of secondary angle */
  79.  
  80. static
  81. int sizeptlist = 0;
  82.  
  83. static
  84. PtGen *ptlist1 = 0,
  85.       *ptlist2 = 0;
  86.  
  87. static
  88. int NumEnts; /* number of angle slices */
  89.  
  90.  
  91. static
  92. bool PrepRev()
  93. {
  94.     NumEnts = RevMesh+1;
  95.  
  96.     /*
  97.      * allocate space 3d descriptions of a point revolved x degrees
  98.      */
  99.     if( NumEnts > sizeptlist ) {
  100.         if( ptlist1 ) free(ptlist1);
  101.         if( ptlist2 ) free(ptlist2);
  102.  
  103.         ptlist1 =(PtGen *) malloc( NumEnts * sizeof(PtGen)  );
  104.         ptlist2 =(PtGen *) malloc( NumEnts * sizeof(PtGen)  );
  105.         if( !ptlist1 || !ptlist2 ) {
  106.             OutErr("PrepRev:not enough memory");
  107.             return(true);
  108.         }
  109.     }
  110.  
  111.  
  112.     if( InitFastTrig( RotStart, RotRange, NumEnts)) return(true);
  113.     secsin = sin((float)SecAngle*PI/180);
  114.     seccos = cos((float)SecAngle*PI/180);
  115.     return (false);
  116. }
  117.  
  118.  
  119. static
  120. void CalcRing(ptlist, xpos, ypos)
  121. register PtGen *ptlist;
  122. float xpos, ypos;
  123. {
  124.     int angle;
  125.  
  126.     for( angle = 0; angle < NumEnts; angle++, ptlist++) {
  127.         float temp;
  128.         /*
  129.          * calculate 3d coordinate of point revolved
  130.          */
  131.         if( RevAxis == RevX) {
  132.             ptlist->d3.y = ypos * fcos(angle);
  133.             temp = ypos * fsin(angle);
  134.             ptlist->d3.x = xpos* seccos - temp *secsin;
  135.             ptlist->d3.z = xpos * secsin + temp * seccos;
  136.         }
  137.         else {
  138.             ptlist->d3.x = xpos * fcos(angle);
  139.             temp = xpos * fsin( angle);
  140.             ptlist->d3.y = ypos * seccos + temp * secsin;
  141.             ptlist->d3.z = secsin * ypos - temp * seccos;
  142.         }
  143.         ptlist->d3.z -= SurfDist;
  144.  
  145.         if( Perspective ) {
  146.             float PerspScale;
  147.  
  148.             PerspScale = fabs(ViewDist / ptlist->d3.z);
  149.             ptlist->d3.x *= PerspScale;
  150.             ptlist->d3.y *= PerspScale;
  151.         }
  152.         /*
  153.          * calculate the 2d screen coordinate equvalent
  154.          */
  155.       /*
  156.         ptlist->d2.x = (short) ptlist->d3.x;
  157.         ptlist->d2.y = (short) ptlist->d3.y;
  158.        */
  159.         ptlist->d2.x = (short) (ptlist->d3.x + 0.5);
  160.         ptlist->d2.y = (short) (ptlist->d3.y + 0.5);
  161.     }
  162. }
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169. /*
  170.  * return true on failure
  171.  */
  172. bool Revolve(acceptfunc)
  173. void (*acceptfunc)();
  174. {
  175.     int segno;
  176.     float tparm, deltat;
  177.     int angle;
  178.     int subseg;
  179.  
  180.     if( PrepRev() ) {
  181.         return(true);
  182.     }
  183.  
  184.     deltat = 1.0/BezMesh;
  185.     RevImageB = 0;
  186.     ResetActSeg();
  187.     do {
  188.         float xpos, ypos;
  189.  
  190.  
  191.         InitCalcBez();
  192.         xpos = StartPtX(GetCurSeg());
  193.         ypos = StartPtY(GetCurSeg());
  194.         CalcRing(ptlist1, xpos, ypos );
  195.         for( subseg = 1; subseg <= BezMesh; subseg++ ) {
  196.             register PtGen *ptlista, *ptlistb;
  197.             register int numpoly;
  198.  
  199.             tparm = subseg * deltat;
  200.             if( subseg & 1 ) {
  201.                 ptlista = ptlist2; ptlistb = ptlist1;
  202.             }
  203.             else {
  204.                 ptlista = ptlist1; ptlistb = ptlist2;
  205.             }
  206.  
  207.             CalcBezPt(tparm, &xpos, &ypos );
  208.             CalcRing( ptlista, xpos, ypos );
  209.             RevImageR = 0;
  210.             for( numpoly = NumEnts -1; numpoly--; ) {
  211.      /*         (* acceptfunc)(ptlista, ptlista+1, ptlistb+1, ptlistb); */
  212.                 (* acceptfunc)(ptlistb, ptlista, ptlista+1, ptlistb+1);
  213.                 ptlista++;
  214.                 ptlistb++;
  215.                 RevImageR++;
  216.             }
  217.             RevImageB++;
  218.         }
  219.         NextSeg();
  220.  
  221.     } while( ActSeg );
  222.     return( false );
  223. }
  224.